View All Projects ↗
Kubernetes · Docker · Helm · Prometheus · Grafana · Loki

CloudOps Kubernetes Observability

An end-to-end observability project that brings together Kubernetes deployment, application metrics, dashboards, centralized logging, and alerting.

View Source Code ↗ Back to Projects ↓
01 / Overview

Project Overview

CloudOps Kubernetes Observability is a containerized Flask application deployed on Kubernetes with a monitoring and logging stack.

The application runs as multiple replicas behind a Kubernetes Service. Helm manages the application deployment, while Prometheus collects metrics, Grafana displays dashboards, and Loki with Grafana Alloy provides centralized application logging.

The project was built and tested locally on Ubuntu using Docker and kind.

02 / Architecture

System Architecture

Data pipeline flow from client port forwarding through the local cluster, metrics collection, and alerting channels.

Local Kubernetes Observability Flow kind cluster · Prometheus · Grafana · Loki
Browser / Port Local Forward K8s Service Flask Pod Replicas Prometheus /metrics Scrape Grafana Alloy Log Collector Alertmanager Rules & Alerts Loki Log Storage Grafana Dashboards Metrics & Explore Logs
03 / Visuals

Project Screenshots

Interfaces captured directly from the local Kubernetes observability deployment.

Flask application deployed and running inside a local Kubernetes cluster
Application Interface Flask application deployed and running inside a local Kubernetes cluster.
Grafana dashboard for visualizing application and infrastructure metrics
Monitoring Dashboard Grafana dashboard for visualizing application and infrastructure metrics.
Prometheus monitoring configuration with the CloudOps application target reporting as UP
Prometheus Monitoring Prometheus monitoring configuration with the CloudOps application target reporting as UP.
Application logs collected by Grafana Alloy and queried through Loki in Grafana Explore
Centralized Logging Application logs collected by Grafana Alloy and queried through Loki in Grafana Explore.
04 / Capabilities

Key Engineering Features

Core implementation aspects across cluster configuration, telemetry, logging, and automated testing.

Kubernetes Deployment

  • Multi-replica application Deployment.
  • ClusterIP Service for internal traffic routing.
  • ConfigMaps, Secrets, and ServiceAccounts.
  • Readiness and liveness probes.

Containerization & Packaging

  • Docker image built locally.
  • Helm chart for Kubernetes resource management.
  • Helm upgrades and rollback support.

Metrics & Dashboards

  • Application metrics exposed through /metrics.
  • Prometheus scraping through a ServiceMonitor.
  • Grafana dashboard for monitoring.
  • Metrics Server integration for CPU-based autoscaling.

Centralized Logging

  • Grafana Alloy discovers application Pods and collects logs.
  • Loki stores and indexes the collected log streams.
  • Logs can be queried through Grafana Explore.

Alerting

  • Prometheus alert rules for application availability, elevated HTTP 5xx error rates, and unavailable replicas.
  • Alertmanager integration for alert handling.

Testing

  • pytest-based application tests.
  • Health, readiness, and status endpoint verification.
05 / Architecture Logic

Technical Implementation

Overview of the decoupled technologies working together in the local environment.

Application

Flask provides the web interface, health endpoints, status information, and Prometheus metrics.

Containerization

Docker packages the application and its dependencies.

Orchestration

kind provides a local Kubernetes cluster for deployment and validation.

Deployment

Helm manages the application's Kubernetes resources and configuration.

Observability

Prometheus collects metrics, Grafana visualizes them, and Loki with Grafana Alloy handles application logs.

Autoscaling

Horizontal Pod Autoscaler uses CPU metrics from Metrics Server to manage the application's replica count.

06 / Competencies

Skills Demonstrated

Kubernetes
Docker
Helm
Prometheus
Grafana
Loki
Python
Flask
Linux
Monitoring
Logging
RBAC
Autoscaling
pytest
07 / Context

Environment & Scope

This project was developed and tested locally on Ubuntu using Docker and kind. The application image is built locally and loaded into the cluster. Monitoring interfaces are accessed through Kubernetes port forwarding.

Built to understand how applications run and are monitored inside Kubernetes.

This project combines containerization, Kubernetes deployment, metrics collection, centralized logging, and alerting into a single local observability environment.

Back to Projects